60 research outputs found
Constructive Provability Logic
We present constructive provability logic, an intuitionstic modal logic that
validates the L\"ob rule of G\"odel and L\"ob's provability logic by permitting
logical reflection over provability. Two distinct variants of this logic, CPL
and CPL*, are presented in natural deduction and sequent calculus forms which
are then shown to be equivalent. In addition, we discuss the use of
constructive provability logic to justify stratified negation in logic
programming within an intuitionstic and structural proof theory.Comment: Extended version of IMLA 2011 submission of the same titl
Domain-Aware Session Types
We develop a generalization of existing Curry-Howard interpretations of (binary) session types by relying on an extension of linear logic with features from hybrid logic, in particular modal worlds that indicate domains. These worlds govern domain migration, subject to a parametric accessibility relation familiar from the Kripke semantics of modal logic. The result is an expressive new typed process framework for domain-aware, message-passing concurrency. Its logical foundations ensure that well-typed processes enjoy session fidelity, global progress, and termination. Typing also ensures that processes only communicate with accessible domains and so respect the accessibility relation.
Remarkably, our domain-aware framework can specify scenarios in which domain information is available only at runtime; flexible accessibility relations can be cleanly defined and statically enforced. As a specific application, we introduce domain-aware multiparty session types, in which global protocols can express arbitrarily nested sub-protocols via domain migration. We develop a precise analysis of these multiparty protocols by reduction to our binary domain-aware framework: complex domain-aware protocols can be reasoned about at the right level of abstraction, ensuring also the principled transfer of key correctness properties from the binary to the multiparty setting
A logical foundation for session-based concurrent computation
Linear logic has long been heralded for its potential of providing a logical basis for concurrency.
While over the years many research attempts were made in this regard, a Curry-Howard correspondence between linear logic and concurrent computation was only found recently, bridging the proof theory of linear logic and session-typed process calculus. Building upon this work, we have
developed a theory of intuitionistic linear logic as a logical foundation for session-based concurrent computation, exploring several concurrency related phenomena such as value-dependent session
types and polymorphic sessions within our logical framework in an arguably clean and elegant way, establishing with relative ease strong typing guarantees due to the logical basis, which ensure the fundamental properties of type preservation and global progress, entailing the absence of deadlocks
in communication.
We develop a general purpose concurrent programming language based on the logical interpretation, combining functional programming with a concurrent, session-based process layer through the form of a contextual monad, preserving our strong typing guarantees of type preservation and
deadlock-freedom in the presence of general recursion and higher-order process communication.
We introduce a notion of linear logical relations for session typed concurrent processes, developing an arguably uniform technique for reasoning about sophisticated properties of session-based concurrent computation such as termination or equivalence based on our logical approach, further supporting our goal of establishing intuitionistic linear logic as a logical foundation for sessionbased concurrency
Cut Reduction in Linear Logic as Asynchronous Session-Typed Communication
Prior work has shown that intuitionistic linear logic can be seen as a
session-type discipline for the pi-calculus, where cut reduction in
the sequent calculus corresponds to synchronous process reduction. In
this paper, we exhibit a new process assignment from the asynchronous,
polyadic pi-calculus to exactly the same proof rules. Proof-theoretically, the difference between these interpretations can
be understood through permutations of inference rules that preserve
observational equivalence of closed processes in the synchronous case.
We also show that, under this new asynchronous interpretation, cut
reductions correspond to a natural asynchronous buffered session
semantics, where each session is allocated a separate communication
buffer
A Universal Session Type for Untyped Asynchronous Communication
In the simply-typed lambda-calculus we can recover the full range of expressiveness of the untyped lambda-calculus solely by adding a single recursive type U = U -> U. In contrast, in the session-typed pi-calculus, recursion alone is insufficient to recover the untyped pi-calculus, primarily due to linearity: each channel just has two unique endpoints. In this paper, we show that shared channels with a corresponding sharing semantics (based on the language SILL_S developed in prior work) are enough to embed the untyped asynchronous pi-calculus via a universal shared session type U_S. We show that our encoding of the asynchronous pi-calculus satisfies operational correspondence and preserves observable actions (i.e., processes are weakly bisimilar to their encoding). Moreover, we clarify the expressiveness of SILL_S by developing an operationally correct encoding of SILL_S in the asynchronous pi-calculus
Ferrite: A Judgmental Embedding of Session Types in Rust
This paper introduces Ferrite, a shallow embedding of session types in Rust.
In contrast to existing session type libraries and embeddings for mainstream
languages, Ferrite not only supports linear session types but also shared
session types. Shared session types allow sharing (aliasing) of channels while
preserving session fidelity (preservation) using type modalities for acquiring
and releasing sessions. Ferrite adopts a propositions as types approach and
encodes typing derivations as Rust functions, with the proof of successful
type-checking manifesting as a Rust program. We provide an evaluation of
Ferrite using Servo as a practical example, and demonstrate how safe
communication can be achieved in the canvas component using Ferrite
- …